Termination w.r.t. Q of the following Term Rewriting System could be proven:
Q restricted rewrite system:
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
↳ QTRS
↳ DependencyPairsProof
Q restricted rewrite system:
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
Q DP problem:
The TRS P consists of the following rules:
PUSH3(E1, E2, calls3(E3, S1, CS1)) -> EQT2(E1, E3)
EQT2(tuple2(H1, T1), tuple2(H2, T2)) -> EQT2(H1, H2)
SUBTRACT2(List, cons2(Head, Tail)) -> DELETE2(Head, List)
EQS2(stack2(E1, S1), stack2(E2, S2)) -> AND2(eqt2(E1, E2), eqs2(S1, S2))
LOCKER2_RELEASE_LOCK2(Lock, Client) -> RECORD_EXTRACT3(Lock, lock, excl)
LOCKER2_REMOVE_PENDING2(Lock, Client) -> RECORD_UPDATES3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
LOCKER2_MAP_PROMOTE_PENDING2(cons2(Lock, Locks), Pending) -> LOCKER2_PROMOTE_PENDING2(Lock, Pending)
LOCKER2_CHECK_AVAILABLE2(Resource, cons2(Lock, Locks)) -> RECORD_EXTRACT3(Lock, lock, resource)
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> EQC2(CS1, CS2)
LOCKER2_CHECK_AVAILABLES2(cons2(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLE2(Resource, Locks)
CASE03(Client, Lock, cons2(Client, Pendings)) -> RECORD_UPDATES3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
ELEMENT2(int1(s1(s1(N1))), tuple2(T1, T2)) -> ELEMENT2(int1(s1(N1)), T2)
MEMBER2(E, cons2(Head, Tail)) -> CASE94(Tail, Head, E, equal2(E, Head))
EQT2(cons2(H1, T1), cons2(H2, T2)) -> AND2(eqt2(H1, H2), eqt2(T1, T2))
LOCKER2_MAP_CLAIM_LOCK3(cons2(Lock, Locks), Resources, Client) -> LOCKER2_MAP_CLAIM_LOCK3(Locks, Resources, Client)
LOCKER2_OBTAINABLES2(cons2(Lock, Locks), Client) -> RECORD_EXTRACT3(Lock, lock, pending)
CASE54(Client, Locks, Lock, true) -> LOCKER2_OBTAINABLES2(Locks, Client)
PUSH16(E1, E2, E3, S1, CS1, T) -> PUSHS2(E2, S1)
LOCKER2_MAP_PROMOTE_PENDING2(cons2(Lock, Locks), Pending) -> LOCKER2_MAP_PROMOTE_PENDING2(Locks, Pending)
SUBTRACT2(List, cons2(Head, Tail)) -> SUBTRACT2(delete2(Head, List), Tail)
DELETE2(E, cons2(Head, Tail)) -> CASE84(Tail, Head, E, equal2(E, Head))
CASE94(Tail, Head, E, false) -> MEMBER2(E, Tail)
LOCKER2_ADD_PENDING3(Lock, Resources, Client) -> CASE14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
LOCKER2_PROMOTE_PENDING2(Lock, Client) -> CASE03(Client, Lock, record_extract3(Lock, lock, pending))
RECORD_UPDATES3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> RECORD_UPDATES3(record_update4(Record, Name, Field, NewF), Name, Fields)
LOCKER2_PROMOTE_PENDING2(Lock, Client) -> RECORD_EXTRACT3(Lock, lock, pending)
LOCKER2_REMOVE_PENDING2(Lock, Client) -> RECORD_EXTRACT3(Lock, lock, pending)
CASE23(Client, Lock, true) -> RECORD_UPDATES3(Lock, lock, cons2(tuple2(excllock, excl), nil))
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> AND2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
RECORD_UPDATES3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> RECORD_UPDATE4(Record, Name, Field, NewF)
LOCKER2_OBTAINABLES2(cons2(Lock, Locks), Client) -> MEMBER2(Client, record_extract3(Lock, lock, pending))
EQS2(stack2(E1, S1), stack2(E2, S2)) -> EQS2(S1, S2)
CASE64(Locks, Lock, Resource, false) -> LOCKER2_CHECK_AVAILABLE2(Resource, Locks)
CASE14(Client, Resources, Lock, true) -> APPEND2(record_extract3(Lock, lock, pending), cons2(Client, nil))
CASE14(Client, Resources, Lock, true) -> RECORD_UPDATES3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
LOCKER2_ADD_PENDING3(Lock, Resources, Client) -> RECORD_EXTRACT3(Lock, lock, resource)
LOCKER2_RELEASE_LOCK2(Lock, Client) -> CASE23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
LOCKER2_ADD_PENDING3(Lock, Resources, Client) -> MEMBER2(record_extract3(Lock, lock, resource), Resources)
CASE14(Client, Resources, Lock, true) -> RECORD_EXTRACT3(Lock, lock, pending)
CASE64(Locks, Lock, Resource, true) -> RECORD_EXTRACT3(Lock, lock, excl)
LOCKER2_RELEASE_LOCK2(Lock, Client) -> GEN_MODTAGEQ2(Client, record_extract3(Lock, lock, excl))
PUSH3(E1, E2, calls3(E3, S1, CS1)) -> PUSH16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
EQT2(tuple2(H1, T1), tuple2(H2, T2)) -> EQT2(T1, T2)
EQT2(tuple2(H1, T1), tuple2(H2, T2)) -> AND2(eqt2(H1, H2), eqt2(T1, T2))
LOCKER2_OBTAINABLES2(cons2(Lock, Locks), Client) -> CASE54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
EQT2(tuplenil1(H1), tuplenil1(H2)) -> EQT2(H1, H2)
EQS2(stack2(E1, S1), stack2(E2, S2)) -> EQT2(E1, E2)
APPEND2(cons2(Head, Tail), List) -> APPEND2(Tail, List)
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> EQT2(E1, E2)
EQT2(cons2(H1, T1), cons2(H2, T2)) -> EQT2(T1, T2)
LOCKER2_CHECK_AVAILABLE2(Resource, cons2(Lock, Locks)) -> CASE64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
CASE64(Locks, Lock, Resource, true) -> RECORD_EXTRACT3(Lock, lock, pending)
ISTOPS2(E1, stack2(E2, S1)) -> EQT2(E1, E2)
EQT2(cons2(H1, T1), cons2(H2, T2)) -> EQT2(H1, H2)
EQT2(pid1(N1), pid1(N2)) -> EQT2(N1, N2)
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> AND2(eqs2(S1, S2), eqc2(CS1, CS2))
LOCKER2_REMOVE_PENDING2(Lock, Client) -> SUBTRACT2(record_extract3(Lock, lock, pending), cons2(Client, nil))
LOCKER2_CHECK_AVAILABLES2(cons2(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLES2(Resources, Locks)
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> EQS2(S1, S2)
CASE54(Client, Locks, Lock, false) -> LOCKER2_OBTAINABLES2(Locks, Client)
CASE84(Tail, Head, E, false) -> DELETE2(E, Tail)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
Q DP problem:
The TRS P consists of the following rules:
PUSH3(E1, E2, calls3(E3, S1, CS1)) -> EQT2(E1, E3)
EQT2(tuple2(H1, T1), tuple2(H2, T2)) -> EQT2(H1, H2)
SUBTRACT2(List, cons2(Head, Tail)) -> DELETE2(Head, List)
EQS2(stack2(E1, S1), stack2(E2, S2)) -> AND2(eqt2(E1, E2), eqs2(S1, S2))
LOCKER2_RELEASE_LOCK2(Lock, Client) -> RECORD_EXTRACT3(Lock, lock, excl)
LOCKER2_REMOVE_PENDING2(Lock, Client) -> RECORD_UPDATES3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
LOCKER2_MAP_PROMOTE_PENDING2(cons2(Lock, Locks), Pending) -> LOCKER2_PROMOTE_PENDING2(Lock, Pending)
LOCKER2_CHECK_AVAILABLE2(Resource, cons2(Lock, Locks)) -> RECORD_EXTRACT3(Lock, lock, resource)
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> EQC2(CS1, CS2)
LOCKER2_CHECK_AVAILABLES2(cons2(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLE2(Resource, Locks)
CASE03(Client, Lock, cons2(Client, Pendings)) -> RECORD_UPDATES3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
ELEMENT2(int1(s1(s1(N1))), tuple2(T1, T2)) -> ELEMENT2(int1(s1(N1)), T2)
MEMBER2(E, cons2(Head, Tail)) -> CASE94(Tail, Head, E, equal2(E, Head))
EQT2(cons2(H1, T1), cons2(H2, T2)) -> AND2(eqt2(H1, H2), eqt2(T1, T2))
LOCKER2_MAP_CLAIM_LOCK3(cons2(Lock, Locks), Resources, Client) -> LOCKER2_MAP_CLAIM_LOCK3(Locks, Resources, Client)
LOCKER2_OBTAINABLES2(cons2(Lock, Locks), Client) -> RECORD_EXTRACT3(Lock, lock, pending)
CASE54(Client, Locks, Lock, true) -> LOCKER2_OBTAINABLES2(Locks, Client)
PUSH16(E1, E2, E3, S1, CS1, T) -> PUSHS2(E2, S1)
LOCKER2_MAP_PROMOTE_PENDING2(cons2(Lock, Locks), Pending) -> LOCKER2_MAP_PROMOTE_PENDING2(Locks, Pending)
SUBTRACT2(List, cons2(Head, Tail)) -> SUBTRACT2(delete2(Head, List), Tail)
DELETE2(E, cons2(Head, Tail)) -> CASE84(Tail, Head, E, equal2(E, Head))
CASE94(Tail, Head, E, false) -> MEMBER2(E, Tail)
LOCKER2_ADD_PENDING3(Lock, Resources, Client) -> CASE14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
LOCKER2_PROMOTE_PENDING2(Lock, Client) -> CASE03(Client, Lock, record_extract3(Lock, lock, pending))
RECORD_UPDATES3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> RECORD_UPDATES3(record_update4(Record, Name, Field, NewF), Name, Fields)
LOCKER2_PROMOTE_PENDING2(Lock, Client) -> RECORD_EXTRACT3(Lock, lock, pending)
LOCKER2_REMOVE_PENDING2(Lock, Client) -> RECORD_EXTRACT3(Lock, lock, pending)
CASE23(Client, Lock, true) -> RECORD_UPDATES3(Lock, lock, cons2(tuple2(excllock, excl), nil))
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> AND2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
RECORD_UPDATES3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> RECORD_UPDATE4(Record, Name, Field, NewF)
LOCKER2_OBTAINABLES2(cons2(Lock, Locks), Client) -> MEMBER2(Client, record_extract3(Lock, lock, pending))
EQS2(stack2(E1, S1), stack2(E2, S2)) -> EQS2(S1, S2)
CASE64(Locks, Lock, Resource, false) -> LOCKER2_CHECK_AVAILABLE2(Resource, Locks)
CASE14(Client, Resources, Lock, true) -> APPEND2(record_extract3(Lock, lock, pending), cons2(Client, nil))
CASE14(Client, Resources, Lock, true) -> RECORD_UPDATES3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
LOCKER2_ADD_PENDING3(Lock, Resources, Client) -> RECORD_EXTRACT3(Lock, lock, resource)
LOCKER2_RELEASE_LOCK2(Lock, Client) -> CASE23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
LOCKER2_ADD_PENDING3(Lock, Resources, Client) -> MEMBER2(record_extract3(Lock, lock, resource), Resources)
CASE14(Client, Resources, Lock, true) -> RECORD_EXTRACT3(Lock, lock, pending)
CASE64(Locks, Lock, Resource, true) -> RECORD_EXTRACT3(Lock, lock, excl)
LOCKER2_RELEASE_LOCK2(Lock, Client) -> GEN_MODTAGEQ2(Client, record_extract3(Lock, lock, excl))
PUSH3(E1, E2, calls3(E3, S1, CS1)) -> PUSH16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
EQT2(tuple2(H1, T1), tuple2(H2, T2)) -> EQT2(T1, T2)
EQT2(tuple2(H1, T1), tuple2(H2, T2)) -> AND2(eqt2(H1, H2), eqt2(T1, T2))
LOCKER2_OBTAINABLES2(cons2(Lock, Locks), Client) -> CASE54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
EQT2(tuplenil1(H1), tuplenil1(H2)) -> EQT2(H1, H2)
EQS2(stack2(E1, S1), stack2(E2, S2)) -> EQT2(E1, E2)
APPEND2(cons2(Head, Tail), List) -> APPEND2(Tail, List)
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> EQT2(E1, E2)
EQT2(cons2(H1, T1), cons2(H2, T2)) -> EQT2(T1, T2)
LOCKER2_CHECK_AVAILABLE2(Resource, cons2(Lock, Locks)) -> CASE64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
CASE64(Locks, Lock, Resource, true) -> RECORD_EXTRACT3(Lock, lock, pending)
ISTOPS2(E1, stack2(E2, S1)) -> EQT2(E1, E2)
EQT2(cons2(H1, T1), cons2(H2, T2)) -> EQT2(H1, H2)
EQT2(pid1(N1), pid1(N2)) -> EQT2(N1, N2)
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> AND2(eqs2(S1, S2), eqc2(CS1, CS2))
LOCKER2_REMOVE_PENDING2(Lock, Client) -> SUBTRACT2(record_extract3(Lock, lock, pending), cons2(Client, nil))
LOCKER2_CHECK_AVAILABLES2(cons2(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLES2(Resources, Locks)
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> EQS2(S1, S2)
CASE54(Client, Locks, Lock, false) -> LOCKER2_OBTAINABLES2(Locks, Client)
CASE84(Tail, Head, E, false) -> DELETE2(E, Tail)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph contains 10 SCCs with 46 less nodes.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
SUBTRACT2(List, cons2(Head, Tail)) -> SUBTRACT2(delete2(Head, List), Tail)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
SUBTRACT2(List, cons2(Head, Tail)) -> SUBTRACT2(delete2(Head, List), Tail)
Used argument filtering: SUBTRACT2(x1, x2) = x2
cons2(x1, x2) = cons1(x2)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
P is empty.
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
APPEND2(cons2(Head, Tail), List) -> APPEND2(Tail, List)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
APPEND2(cons2(Head, Tail), List) -> APPEND2(Tail, List)
Used argument filtering: APPEND2(x1, x2) = x1
cons2(x1, x2) = cons1(x2)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
P is empty.
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
LOCKER2_CHECK_AVAILABLES2(cons2(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLES2(Resources, Locks)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
LOCKER2_CHECK_AVAILABLES2(cons2(Resource, Resources), Locks) -> LOCKER2_CHECK_AVAILABLES2(Resources, Locks)
Used argument filtering: LOCKER2_CHECK_AVAILABLES2(x1, x2) = x1
cons2(x1, x2) = cons1(x2)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
P is empty.
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
LOCKER2_MAP_CLAIM_LOCK3(cons2(Lock, Locks), Resources, Client) -> LOCKER2_MAP_CLAIM_LOCK3(Locks, Resources, Client)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
LOCKER2_MAP_CLAIM_LOCK3(cons2(Lock, Locks), Resources, Client) -> LOCKER2_MAP_CLAIM_LOCK3(Locks, Resources, Client)
Used argument filtering: LOCKER2_MAP_CLAIM_LOCK3(x1, x2, x3) = x1
cons2(x1, x2) = cons1(x2)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
P is empty.
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
RECORD_UPDATES3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> RECORD_UPDATES3(record_update4(Record, Name, Field, NewF), Name, Fields)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
RECORD_UPDATES3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> RECORD_UPDATES3(record_update4(Record, Name, Field, NewF), Name, Fields)
Used argument filtering: RECORD_UPDATES3(x1, x2, x3) = x3
cons2(x1, x2) = cons1(x2)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
P is empty.
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
LOCKER2_MAP_PROMOTE_PENDING2(cons2(Lock, Locks), Pending) -> LOCKER2_MAP_PROMOTE_PENDING2(Locks, Pending)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
LOCKER2_MAP_PROMOTE_PENDING2(cons2(Lock, Locks), Pending) -> LOCKER2_MAP_PROMOTE_PENDING2(Locks, Pending)
Used argument filtering: LOCKER2_MAP_PROMOTE_PENDING2(x1, x2) = x1
cons2(x1, x2) = cons1(x2)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
P is empty.
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
ELEMENT2(int1(s1(s1(N1))), tuple2(T1, T2)) -> ELEMENT2(int1(s1(N1)), T2)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
ELEMENT2(int1(s1(s1(N1))), tuple2(T1, T2)) -> ELEMENT2(int1(s1(N1)), T2)
Used argument filtering: ELEMENT2(x1, x2) = x2
tuple2(x1, x2) = tuple1(x2)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ QDP
↳ QDP
Q DP problem:
P is empty.
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
EQT2(tuple2(H1, T1), tuple2(H2, T2)) -> EQT2(H1, H2)
EQT2(tuplenil1(H1), tuplenil1(H2)) -> EQT2(H1, H2)
EQT2(pid1(N1), pid1(N2)) -> EQT2(N1, N2)
EQT2(cons2(H1, T1), cons2(H2, T2)) -> EQT2(T1, T2)
EQT2(tuple2(H1, T1), tuple2(H2, T2)) -> EQT2(T1, T2)
EQT2(cons2(H1, T1), cons2(H2, T2)) -> EQT2(H1, H2)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
EQT2(tuple2(H1, T1), tuple2(H2, T2)) -> EQT2(H1, H2)
EQT2(cons2(H1, T1), cons2(H2, T2)) -> EQT2(T1, T2)
EQT2(tuple2(H1, T1), tuple2(H2, T2)) -> EQT2(T1, T2)
EQT2(cons2(H1, T1), cons2(H2, T2)) -> EQT2(H1, H2)
Used argument filtering: EQT2(x1, x2) = x2
tuple2(x1, x2) = tuple2(x1, x2)
tuplenil1(x1) = x1
pid1(x1) = x1
cons2(x1, x2) = cons2(x1, x2)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
EQT2(pid1(N1), pid1(N2)) -> EQT2(N1, N2)
EQT2(tuplenil1(H1), tuplenil1(H2)) -> EQT2(H1, H2)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
EQT2(tuplenil1(H1), tuplenil1(H2)) -> EQT2(H1, H2)
Used argument filtering: EQT2(x1, x2) = x2
pid1(x1) = x1
tuplenil1(x1) = tuplenil1(x1)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
EQT2(pid1(N1), pid1(N2)) -> EQT2(N1, N2)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
EQT2(pid1(N1), pid1(N2)) -> EQT2(N1, N2)
Used argument filtering: EQT2(x1, x2) = x2
pid1(x1) = pid1(x1)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ PisEmptyProof
↳ QDP
↳ QDP
Q DP problem:
P is empty.
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
Q DP problem:
The TRS P consists of the following rules:
EQS2(stack2(E1, S1), stack2(E2, S2)) -> EQS2(S1, S2)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
EQS2(stack2(E1, S1), stack2(E2, S2)) -> EQS2(S1, S2)
Used argument filtering: EQS2(x1, x2) = x2
stack2(x1, x2) = stack1(x2)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ PisEmptyProof
↳ QDP
Q DP problem:
P is empty.
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
Q DP problem:
The TRS P consists of the following rules:
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> EQC2(CS1, CS2)
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using an argument filtering and a montonic ordering, at least one Dependency Pair of this SCC can be strictly oriented.
EQC2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> EQC2(CS1, CS2)
Used argument filtering: EQC2(x1, x2) = x2
calls3(x1, x2, x3) = calls1(x3)
Used ordering: Quasi Precedence:
trivial
↳ QTRS
↳ DependencyPairsProof
↳ QDP
↳ DependencyGraphProof
↳ AND
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDP
↳ QDPAfsSolverProof
↳ QDP
↳ PisEmptyProof
Q DP problem:
P is empty.
The TRS R consists of the following rules:
or2(T, T) -> T
or2(F, T) -> T
or2(T, F) -> T
or2(F, F) -> F
and2(T, B) -> B
and2(B, T) -> B
and2(F, B) -> F
and2(B, F) -> F
imp2(T, B) -> B
imp2(F, B) -> T
not1(T) -> F
not1(F) -> T
if3(T, B1, B2) -> B1
if3(F, B1, B2) -> B2
eq2(T, T) -> T
eq2(F, F) -> T
eq2(T, F) -> F
eq2(F, T) -> F
eqt2(nil, undefined) -> F
eqt2(nil, pid1(N2)) -> F
eqt2(nil, int1(N2)) -> F
eqt2(nil, cons2(H2, T2)) -> F
eqt2(nil, tuple2(H2, T2)) -> F
eqt2(nil, tuplenil1(H2)) -> F
eqt2(a, nil) -> F
eqt2(a, a) -> T
eqt2(a, excl) -> F
eqt2(a, false) -> F
eqt2(a, lock) -> F
eqt2(a, locker) -> F
eqt2(a, mcrlrecord) -> F
eqt2(a, ok) -> F
eqt2(a, pending) -> F
eqt2(a, release) -> F
eqt2(a, request) -> F
eqt2(a, resource) -> F
eqt2(a, tag) -> F
eqt2(a, true) -> F
eqt2(a, undefined) -> F
eqt2(a, pid1(N2)) -> F
eqt2(a, int1(N2)) -> F
eqt2(a, cons2(H2, T2)) -> F
eqt2(a, tuple2(H2, T2)) -> F
eqt2(a, tuplenil1(H2)) -> F
eqt2(excl, nil) -> F
eqt2(excl, a) -> F
eqt2(excl, excl) -> T
eqt2(excl, false) -> F
eqt2(excl, lock) -> F
eqt2(excl, locker) -> F
eqt2(excl, mcrlrecord) -> F
eqt2(excl, ok) -> F
eqt2(excl, pending) -> F
eqt2(excl, release) -> F
eqt2(excl, request) -> F
eqt2(excl, resource) -> F
eqt2(excl, tag) -> F
eqt2(excl, true) -> F
eqt2(excl, undefined) -> F
eqt2(excl, pid1(N2)) -> F
eqt2(excl, eqt2(false, int1(N2))) -> F
eqt2(false, cons2(H2, T2)) -> F
eqt2(false, tuple2(H2, T2)) -> F
eqt2(false, tuplenil1(H2)) -> F
eqt2(lock, nil) -> F
eqt2(lock, a) -> F
eqt2(lock, excl) -> F
eqt2(lock, false) -> F
eqt2(lock, lock) -> T
eqt2(lock, locker) -> F
eqt2(lock, mcrlrecord) -> F
eqt2(lock, ok) -> F
eqt2(lock, pending) -> F
eqt2(lock, release) -> F
eqt2(lock, request) -> F
eqt2(lock, resource) -> F
eqt2(lock, tag) -> F
eqt2(lock, true) -> F
eqt2(lock, undefined) -> F
eqt2(lock, pid1(N2)) -> F
eqt2(lock, int1(N2)) -> F
eqt2(lock, cons2(H2, T2)) -> F
eqt2(lock, tuple2(H2, T2)) -> F
eqt2(lock, tuplenil1(H2)) -> F
eqt2(locker, nil) -> F
eqt2(locker, a) -> F
eqt2(locker, excl) -> F
eqt2(locker, false) -> F
eqt2(locker, lock) -> F
eqt2(locker, locker) -> T
eqt2(locker, mcrlrecord) -> F
eqt2(locker, ok) -> F
eqt2(locker, pending) -> F
eqt2(locker, release) -> F
eqt2(locker, request) -> F
eqt2(locker, resource) -> F
eqt2(locker, tag) -> F
eqt2(locker, true) -> F
eqt2(locker, undefined) -> F
eqt2(locker, pid1(N2)) -> F
eqt2(locker, int1(N2)) -> F
eqt2(locker, cons2(H2, T2)) -> F
eqt2(locker, tuple2(H2, T2)) -> F
eqt2(locker, tuplenil1(H2)) -> F
eqt2(mcrlrecord, nil) -> F
eqt2(mcrlrecord, a) -> F
eqt2(mcrlrecord, excl) -> F
eqt2(mcrlrecord, false) -> F
eqt2(mcrlrecord, lock) -> F
eqt2(mcrlrecord, locker) -> F
eqt2(mcrlrecord, mcrlrecord) -> T
eqt2(mcrlrecord, ok) -> F
eqt2(mcrlrecord, pending) -> F
eqt2(mcrlrecord, release) -> F
eqt2(mcrlrecord, request) -> F
eqt2(mcrlrecord, resource) -> F
eqt2(ok, resource) -> F
eqt2(ok, tag) -> F
eqt2(ok, true) -> F
eqt2(ok, undefined) -> F
eqt2(ok, pid1(N2)) -> F
eqt2(ok, int1(N2)) -> F
eqt2(ok, cons2(H2, T2)) -> F
eqt2(ok, tuple2(H2, T2)) -> F
eqt2(ok, tuplenil1(H2)) -> F
eqt2(pending, nil) -> F
eqt2(pending, a) -> F
eqt2(pending, excl) -> F
eqt2(pending, false) -> F
eqt2(pending, lock) -> F
eqt2(pending, locker) -> F
eqt2(pending, mcrlrecord) -> F
eqt2(pending, ok) -> F
eqt2(pending, pending) -> T
eqt2(pending, release) -> F
eqt2(pending, request) -> F
eqt2(pending, resource) -> F
eqt2(pending, tag) -> F
eqt2(pending, true) -> F
eqt2(pending, undefined) -> F
eqt2(pending, pid1(N2)) -> F
eqt2(pending, int1(N2)) -> F
eqt2(pending, cons2(H2, T2)) -> F
eqt2(pending, tuple2(H2, T2)) -> F
eqt2(pending, tuplenil1(H2)) -> F
eqt2(release, nil) -> F
eqt2(release, a) -> F
eqt2(release, excl) -> F
eqt2(release, false) -> F
eqt2(release, lock) -> F
eqt2(release, locker) -> F
eqt2(release, mcrlrecord) -> F
eqt2(release, ok) -> F
eqt2(request, mcrlrecord) -> F
eqt2(request, ok) -> F
eqt2(request, pending) -> F
eqt2(request, release) -> F
eqt2(request, request) -> T
eqt2(request, resource) -> F
eqt2(request, tag) -> F
eqt2(request, true) -> F
eqt2(request, undefined) -> F
eqt2(request, pid1(N2)) -> F
eqt2(request, int1(N2)) -> F
eqt2(request, cons2(H2, T2)) -> F
eqt2(request, tuple2(H2, T2)) -> F
eqt2(request, tuplenil1(H2)) -> F
eqt2(resource, nil) -> F
eqt2(resource, a) -> F
eqt2(resource, excl) -> F
eqt2(resource, false) -> F
eqt2(resource, lock) -> F
eqt2(resource, locker) -> F
eqt2(resource, mcrlrecord) -> F
eqt2(resource, ok) -> F
eqt2(resource, pending) -> F
eqt2(resource, release) -> F
eqt2(resource, request) -> F
eqt2(resource, resource) -> T
eqt2(resource, tag) -> F
eqt2(resource, true) -> F
eqt2(resource, undefined) -> F
eqt2(resource, pid1(N2)) -> F
eqt2(resource, int1(N2)) -> F
eqt2(resource, cons2(H2, T2)) -> F
eqt2(resource, tuple2(H2, T2)) -> F
eqt2(resource, tuplenil1(H2)) -> F
eqt2(tag, nil) -> F
eqt2(tag, a) -> F
eqt2(tag, excl) -> F
eqt2(tag, false) -> F
eqt2(tag, lock) -> F
eqt2(tag, locker) -> F
eqt2(tag, mcrlrecord) -> F
eqt2(tag, ok) -> F
eqt2(tag, pending) -> F
eqt2(tag, release) -> F
eqt2(tag, request) -> F
eqt2(tag, resource) -> F
eqt2(tag, tag) -> T
eqt2(tag, true) -> F
eqt2(tag, undefined) -> F
eqt2(tag, pid1(N2)) -> F
eqt2(tag, int1(N2)) -> F
eqt2(tag, cons2(H2, T2)) -> F
eqt2(tag, tuple2(H2, T2)) -> F
eqt2(tag, tuplenil1(H2)) -> F
eqt2(true, nil) -> F
eqt2(true, a) -> F
eqt2(true, excl) -> F
eqt2(true, false) -> F
eqt2(true, lock) -> F
eqt2(true, locker) -> F
eqt2(true, mcrlrecord) -> F
eqt2(true, ok) -> F
eqt2(true, pending) -> F
eqt2(true, release) -> F
eqt2(true, request) -> F
eqt2(true, resource) -> F
eqt2(true, tag) -> F
eqt2(true, true) -> T
eqt2(true, undefined) -> F
eqt2(true, pid1(N2)) -> F
eqt2(true, int1(N2)) -> F
eqt2(true, cons2(H2, T2)) -> F
eqt2(true, tuple2(H2, T2)) -> F
eqt2(true, tuplenil1(H2)) -> F
eqt2(undefined, nil) -> F
eqt2(undefined, a) -> F
eqt2(undefined, tuplenil1(H2)) -> F
eqt2(pid1(N1), nil) -> F
eqt2(pid1(N1), a) -> F
eqt2(pid1(N1), excl) -> F
eqt2(pid1(N1), false) -> F
eqt2(pid1(N1), lock) -> F
eqt2(pid1(N1), locker) -> F
eqt2(pid1(N1), mcrlrecord) -> F
eqt2(pid1(N1), ok) -> F
eqt2(pid1(N1), pending) -> F
eqt2(pid1(N1), release) -> F
eqt2(pid1(N1), request) -> F
eqt2(pid1(N1), resource) -> F
eqt2(pid1(N1), tag) -> F
eqt2(pid1(N1), true) -> F
eqt2(pid1(N1), undefined) -> F
eqt2(pid1(N1), pid1(N2)) -> eqt2(N1, N2)
eqt2(pid1(N1), int1(N2)) -> F
eqt2(pid1(N1), cons2(H2, T2)) -> F
eqt2(pid1(N1), tuple2(H2, T2)) -> F
eqt2(pid1(N1), tuplenil1(H2)) -> F
eqt2(int1(N1), nil) -> F
eqt2(int1(N1), a) -> F
eqt2(int1(N1), excl) -> F
eqt2(int1(N1), false) -> F
eqt2(int1(N1), lock) -> F
eqt2(int1(N1), locker) -> F
eqt2(int1(N1), mcrlrecord) -> F
eqt2(int1(N1), ok) -> F
eqt2(int1(N1), pending) -> F
eqt2(int1(N1), release) -> F
eqt2(int1(N1), request) -> F
eqt2(int1(N1), resource) -> F
eqt2(int1(N1), tag) -> F
eqt2(int1(N1), true) -> F
eqt2(int1(N1), undefined) -> F
eqt2(cons2(H1, T1), resource) -> F
eqt2(cons2(H1, T1), tag) -> F
eqt2(cons2(H1, T1), true) -> F
eqt2(cons2(H1, T1), undefined) -> F
eqt2(cons2(H1, T1), pid1(N2)) -> F
eqt2(cons2(H1, T1), int1(N2)) -> F
eqt2(cons2(H1, T1), cons2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(cons2(H1, T1), tuple2(H2, T2)) -> F
eqt2(cons2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuple2(H1, T1), nil) -> F
eqt2(tuple2(H1, T1), a) -> F
eqt2(tuple2(H1, T1), excl) -> F
eqt2(tuple2(H1, T1), false) -> F
eqt2(tuple2(H1, T1), lock) -> F
eqt2(tuple2(H1, T1), locker) -> F
eqt2(tuple2(H1, T1), mcrlrecord) -> F
eqt2(tuple2(H1, T1), ok) -> F
eqt2(tuple2(H1, T1), pending) -> F
eqt2(tuple2(H1, T1), release) -> F
eqt2(tuple2(H1, T1), request) -> F
eqt2(tuple2(H1, T1), resource) -> F
eqt2(tuple2(H1, T1), tag) -> F
eqt2(tuple2(H1, T1), true) -> F
eqt2(tuple2(H1, T1), undefined) -> F
eqt2(tuple2(H1, T1), pid1(N2)) -> F
eqt2(tuple2(H1, T1), int1(N2)) -> F
eqt2(tuple2(H1, T1), cons2(H2, T2)) -> F
eqt2(tuple2(H1, T1), tuple2(H2, T2)) -> and2(eqt2(H1, H2), eqt2(T1, T2))
eqt2(tuple2(H1, T1), tuplenil1(H2)) -> F
eqt2(tuplenil1(H1), nil) -> F
eqt2(tuplenil1(H1), a) -> F
eqt2(tuplenil1(H1), excl) -> F
eqt2(tuplenil1(H1), false) -> F
eqt2(tuplenil1(H1), lock) -> F
eqt2(tuplenil1(H1), locker) -> F
eqt2(tuplenil1(H1), mcrlrecord) -> F
eqt2(tuplenil1(H1), ok) -> F
eqt2(tuplenil1(H1), pending) -> F
eqt2(tuplenil1(H1), release) -> F
eqt2(tuplenil1(H1), request) -> F
eqt2(tuplenil1(H1), resource) -> F
eqt2(tuplenil1(H1), tag) -> F
eqt2(tuplenil1(H1), true) -> F
eqt2(tuplenil1(H1), undefined) -> F
eqt2(tuplenil1(H1), pid1(N2)) -> F
eqt2(tuplenil1(H1), int1(N2)) -> F
eqt2(tuplenil1(H1), cons2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuple2(H2, T2)) -> F
eqt2(tuplenil1(H1), tuplenil1(H2)) -> eqt2(H1, H2)
element2(int1(s1(0)), tuplenil1(T1)) -> T1
element2(int1(s1(0)), tuple2(T1, T2)) -> T1
element2(int1(s1(s1(N1))), tuple2(T1, T2)) -> element2(int1(s1(N1)), T2)
record_new1(lock) -> tuple2(mcrlrecord, tuple2(lock, tuple2(undefined, tuple2(nil, tuplenil1(nil)))))
record_extract3(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, resource) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2)))))
record_update4(tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(F2))))), lock, pending, NewF) -> tuple2(mcrlrecord, tuple2(lock, tuple2(F0, tuple2(F1, tuplenil1(NewF)))))
record_updates3(Record, Name, nil) -> Record
record_updates3(Record, Name, cons2(tuple2(Field, tuplenil1(NewF)), Fields)) -> record_updates3(record_update4(Record, Name, Field, NewF), Name, Fields)
locker2_map_promote_pending2(nil, Pending) -> nil
locker2_map_promote_pending2(cons2(Lock, Locks), Pending) -> cons2(locker2_promote_pending2(Lock, Pending), locker2_map_promote_pending2(Locks, Pending))
locker2_map_claim_lock3(nil, Resources, Client) -> nil
locker2_map_claim_lock3(cons2(Lock, Locks), Resources, Client) -> cons2(locker2_claim_lock3(Lock, Resources, Client), locker2_map_claim_lock3(Locks, Resources, Client))
locker2_map_add_pending3(nil, Resources, Client) -> nil
locker2_promote_pending2(Lock, Client) -> case03(Client, Lock, record_extract3(Lock, lock, pending))
case03(Client, Lock, cons2(Client, Pendings)) -> record_updates3(Lock, lock, cons2(tuple2(excl, tuplenil1(Client)), cons2(tuple2(pending, tuplenil1(Pendings)), nil)))
case03(Client, Lock, MCRLFree0) -> Lock
locker2_remove_pending2(Lock, Client) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(subtract2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
locker2_add_pending3(Lock, Resources, Client) -> case14(Client, Resources, Lock, member2(record_extract3(Lock, lock, resource), Resources))
case14(Client, Resources, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(pending, tuplenil1(append2(record_extract3(Lock, lock, pending), cons2(Client, nil)))), nil))
case14(Client, Resources, Lock, false) -> Lock
locker2_release_lock2(Lock, Client) -> case23(Client, Lock, gen_modtageq2(Client, record_extract3(Lock, lock, excl)))
case23(Client, Lock, true) -> record_updates3(Lock, lock, cons2(tuple2(excllock, excl), nil))
case43(Client, Lock, MCRLFree1) -> false
locker2_obtainables2(nil, Client) -> true
locker2_obtainables2(cons2(Lock, Locks), Client) -> case54(Client, Locks, Lock, member2(Client, record_extract3(Lock, lock, pending)))
case54(Client, Locks, Lock, true) -> andt2(locker2_obtainable2(Lock, Client), locker2_obtainables2(Locks, Client))
case54(Client, Locks, Lock, false) -> locker2_obtainables2(Locks, Client)
locker2_check_available2(Resource, nil) -> false
locker2_check_available2(Resource, cons2(Lock, Locks)) -> case64(Locks, Lock, Resource, equal2(Resource, record_extract3(Lock, lock, resource)))
case64(Locks, Lock, Resource, true) -> andt2(equal2(record_extract3(Lock, lock, excl), nil), equal2(record_extract3(Lock, lock, pending), nil))
case64(Locks, Lock, Resource, false) -> locker2_check_available2(Resource, Locks)
locker2_check_availables2(nil, Locks) -> true
locker2_check_availables2(cons2(Resource, Resources), Locks) -> andt2(locker2_check_available2(Resource, Locks), locker2_check_availables2(Resources, Locks))
locker2_adduniq2(nil, List) -> List
append2(cons2(Head, Tail), List) -> cons2(Head, append2(Tail, List))
subtract2(List, nil) -> List
subtract2(List, cons2(Head, Tail)) -> subtract2(delete2(Head, List), Tail)
delete2(E, nil) -> nil
delete2(E, cons2(Head, Tail)) -> case84(Tail, Head, E, equal2(E, Head))
case84(Tail, Head, E, true) -> Tail
case84(Tail, Head, E, false) -> cons2(Head, delete2(E, Tail))
gen_tag1(Pid) -> tuple2(Pid, tuplenil1(tag))
gen_modtageq2(Client1, Client2) -> equal2(Client1, Client2)
member2(E, nil) -> false
member2(E, cons2(Head, Tail)) -> case94(Tail, Head, E, equal2(E, Head))
case94(Tail, Head, E, true) -> true
case94(Tail, Head, E, false) -> member2(E, Tail)
eqs2(empty, empty) -> T
eqs2(empty, stack2(E2, S2)) -> F
eqs2(stack2(E1, S1), empty) -> F
eqs2(stack2(E1, S1), stack2(E2, S2)) -> and2(eqt2(E1, E2), eqs2(S1, S2))
pushs2(E1, S1) -> stack2(E1, S1)
pops1(stack2(E1, S1)) -> S1
tops1(stack2(E1, S1)) -> E1
istops2(E1, empty) -> F
istops2(E1, stack2(E2, S1)) -> eqt2(E1, E2)
eqc2(nocalls, nocalls) -> T
eqc2(nocalls, calls3(E2, S2, CS2)) -> F
eqc2(calls3(E1, S1, CS1), nocalls) -> F
eqc2(calls3(E1, S1, CS1), calls3(E2, S2, CS2)) -> and2(eqt2(E1, E2), and2(eqs2(S1, S2), eqc2(CS1, CS2)))
push3(E1, E2, nocalls) -> calls3(E1, stack2(E2, empty), nocalls)
push3(E1, E2, calls3(E3, S1, CS1)) -> push16(E1, E2, E3, S1, CS1, eqt2(E1, E3))
push16(E1, E2, E3, S1, CS1, T) -> calls3(E3, pushs2(E2, S1), CS1)
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.